.TH std::basic_stringbuf::seekoff 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::basic_stringbuf::seekoff \- std::basic_stringbuf::seekoff

.SH Synopsis
   protected:

   virtual pos_type seekoff( off_type off,
                             std::ios_base::seekdir dir,

                             std::ios_base::openmode which = std::ios_base::in |
   std::ios_base::out );

   Repositions std::basic_streambuf::gptr and/or std::basic_streambuf::pptr, if
   possible, to the position that corresponds to exactly off characters from beginning,
   end, or current position of the get and/or put area of the buffer.

     * If which includes std::ios_base::in and this buffer is open for reading (that
       is, if (which & std::ios_base::in) == std::ios_base::in), then repositions the
       read pointer std::basic_streambuf::gptr inside the get area as described below
     * If which includes std::ios_base::out and this buffer is open for writing (that
       is, (which & std::ios_base::out) == std::ios_base::out), then repositions the
       write pointer std::basic_streambuf::pptr inside the put area as described below
     * If which includes both std::ios_base::in and std::ios_base::out and the buffer
       is open for both reading and writing (that is, (which & (std::ios_base::in |
       std::ios_base::out)) == (std::ios_base::in | std::ios_base::out)), and dir is
       either std::ios_base::beg or std::ios_base::end, then repositions both read and
       write pointers as described below.
     * Otherwise, this function fails.

   If gptr and/or pptr is repositioned, it is done as follows:

   1) The new pointer offset newoff of type off_type is determined
   a) if dir == std::ios_base::beg, then newoff is zero
   b) if dir == std::ios_base::cur, then newoff is the current position of the pointer
   (gptr() - eback() or pptr() - pbase())
   c) if dir == std::ios_base::end, then newoff is the length of the entire initialized
   part of the buffer (if over-allocation is used, the high watermark pointer minus the
   beginning pointer)
   2) If the pointer to be repositioned is a null pointer and newoff would be non-zero,
   this function fails.
   3) If newoff + off < 0 (the repositioning would move the pointer to before the
   beginning of the buffer) or if newoff + off would point past the end of the buffer
   (or past the last initialized character in the buffer if over-allocation is used),
   the function fails.
   4) Otherwise, the pointer is assigned as if by gptr() = eback() + newoff + off or
   pptr() = pbase() + newoff + off.

.SH Parameters

   off   - relative position to set the next pointer(s) to
           defines base position to apply the relative offset to. It can be one of the
           following constants:

   dir   - Constant Explanation
           beg      the beginning of a stream
           end      the ending of a stream
           cur      the current position of stream position indicator
           defines whether the input sequences, the output sequence, or both are
           affected. It can be one or a combination of the following constants:
   which -
           Constant Explanation
           in       affect the input sequence
           out      affect the output sequence

.SH Return value

   pos_type(newoff) on success, pos_type(off_type(-1)) on failure or if pos_type cannot
   represent the resulting stream position.

.SH Example


// Run this code

 #include <iostream>
 #include <sstream>

 int main()
 {
     std::stringstream ss("123"); // in/out
     std::cout << "put pos = " << ss.tellp()
               << " get pos = " << ss.tellg() << '\\n';

     // absolute positioning both pointers
     ss.rdbuf()->pubseekoff(1, std::ios_base::beg); // move both 1 forward
     std::cout << "put pos = " << ss.tellp()
               << " get pos = " << ss.tellg() << '\\n';

     // try to move both pointers 1 forward from current position
     if (-1 == ss.rdbuf()->pubseekoff(1, std::ios_base::cur))
         std::cout << "moving both pointers from current position failed\\n";
     std::cout << "put pos = " << ss.tellp()
               << " get pos = " << ss.tellg() << '\\n';

     // move the write pointer 1 forward, but not the read pointer
     // can also be called as ss.seekp(1, std::ios_base::cur);
     ss.rdbuf()->pubseekoff(1, std::ios_base::cur, std::ios_base::out);
     std::cout << "put pos = " << ss.tellp()
               << " get pos = " << ss.tellg() << '\\n';

     ss << 'a'; // write at put position
     std::cout << "Wrote 'a' at put position, the buffer is now " << ss.str() << '\\n';

     char ch;
     ss >> ch;
     std::cout << "reading at get position gives '" << ch << "'\\n";
 }

.SH Output:

 put pos = 0 get pos = 0
 put pos = 1 get pos = 1
 moving both pointers from current position failed
 put pos = 1 get pos = 1
 put pos = 2 get pos = 1
 Wrote 'a' at put position, the buffer is now 12a
 reading at get position gives '2'

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

     DR    Applied to         Behavior as published              Correct behavior
   LWG 55  C++98      seekoff returned an undefined         pos_type(off_type(-1))
                      invalid stream position on failure    is returned on failure
                      static constant members of
   LWG 375 C++98      std::ios_base were                    corrected
                      misspecified as members of
                      std::basic_ios
                      seekoff might succeed even if newoff
   LWG 432 C++98      + off                                 seekoff fails
                      would point past the last initialized in this case
                      character
                      repositioning null gptr() and/or null
   LWG 453 C++98      pptr()                                it can succeed in this case
                      with a new offset of zero always
                      failed
                      the end pointer could not be used to
   LWG 563 C++98      calculate newoff because it could     use the high watermark
                      not be precisely controlled by the    pointer instead
                      program after resolving LWG issue 432

.SH See also

   pubseekoff invokes seekoff()
              \fI(public member function of std::basic_streambuf<CharT,Traits>)\fP
   seekpos    repositions the next pointer in the input sequence, output sequence, or
   \fB[virtual]\fP  both using absolute addressing
              \fI(virtual protected member function)\fP
   seekoff    repositions the file position, using relative addressing
   \fB[virtual]\fP  \fI(virtual protected member function of std::basic_filebuf<CharT,Traits>)\fP

   seekoff    repositions the next pointer in the input sequence, output sequence, or
   \fB[virtual]\fP  both, using relative addressing
              \fI(virtual protected member function of std::strstreambuf)\fP
